home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume24 / zsh2.1 / part12 < prev    next >
Encoding:
Text File  |  1991-10-26  |  48.2 KB  |  2,241 lines
  1. Newsgroups: comp.sources.misc
  2. From: pfalstad@phoenix.Princeton.EDU (Paul Falstad)
  3. Subject:  v24i012:  zsh2.1 - The Z shell, Part12/19
  4. Message-ID: <1991Oct26.014937.19512@sparky.imd.sterling.com>
  5. X-Md4-Signature: 62f8a3ddeea292d7224a63ad5835cf67
  6. Date: Sat, 26 Oct 1991 01:49:37 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: pfalstad@phoenix.Princeton.EDU (Paul Falstad)
  10. Posting-number: Volume 24, Issue 12
  11. Archive-name: zsh2.1/part12
  12. Environment: BSD
  13. Supersedes: zsh2.00: Volume 18, Issue 84-98
  14.  
  15. #!/bin/sh
  16. # this is zshar.12 (part 12 of zsh2.1.0)
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file zsh2.1/src/zle_main.c continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 12; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test ! -f _shar_wnt_.tmp; then
  33.     echo 'x - still skipping zsh2.1/src/zle_main.c'
  34. else
  35. echo 'x - continuing file zsh2.1/src/zle_main.c'
  36. sed 's/^X//' << 'SHAR_EOF' >> 'zsh2.1/src/zle_main.c' &&
  37. X        FD_SET(0,&foofd);
  38. X        if ((tv.tv_usec = cost*costmult) > 500000)
  39. X            tv.tv_usec = 500000;
  40. X        if (!kungetct
  41. X#ifdef HAS_SELECT
  42. X            && !select(1,&foofd,NULL,NULL,&tv)
  43. X#endif
  44. X            )
  45. X            refresh();
  46. X        }
  47. X    if (menucmp)
  48. X        freemenu();
  49. X    statusline = NULL;
  50. X    trashzle();
  51. X    alarm(0);
  52. X    z = strlen(line);
  53. X    line[z] = '\n';
  54. X    line[z+1] = 0;
  55. X    heapalloc();
  56. X    if (curhistline)
  57. X        free(curhistline);
  58. X    if (eofsent)
  59. X        {
  60. X        free(line);
  61. X        line = NULL;
  62. X        }
  63. X    zleactive = 0;
  64. X    freeundo();
  65. X    return line;
  66. X}
  67. X
  68. Xint getkeycmd() /**/
  69. X{
  70. Xchar buf[10];
  71. Xint t0,ret;
  72. XKey ky;
  73. X
  74. X    t0 = 1;
  75. X    cky = NULL;
  76. X    if ((c = getkey(1)) == -1)
  77. X        return -1;
  78. X    if ((ret = bindtab[c]) == z_sequenceleadin)
  79. X        {
  80. X        buf[0] = (c) ? c : 0x80;
  81. X        for (;;)
  82. X            {
  83. X            c = getkey(0);
  84. X            buf[t0++] = (c) ? c : 0x80;
  85. X            buf[t0] = '\0';
  86. X            if (!(ky = (Key) gethnode(buf,xbindtab)))
  87. X                return z_undefinedkey;
  88. X            if (ky->func != z_sequenceleadin)
  89. X                {
  90. X                cky = ky;
  91. X                ret = ky->func;
  92. X                break;
  93. X                }
  94. X            }
  95. X        }
  96. X    if (ret == z_vidigitorbeginningofline)
  97. X        ret = (lastcmd & ZLE_ARG) ? z_digitargument : z_beginningofline;
  98. X    else if (ret == z_executenamedcmd)
  99. X        ret = executenamedcommand();
  100. X    else if (ret == z_executelastnamedcmd)
  101. X        ret = lastnamed;
  102. X    return ret;
  103. X}
  104. X
  105. Xvoid sendstring() /**/
  106. X{
  107. Xchar buf[2];
  108. X
  109. X    buf[0] = c;
  110. X    buf[1] = '\0';
  111. X    if (!cky)
  112. X        cky = (Key) gethnode(buf,xbindtab);
  113. X    ungetkeys(cky->str,cky->len);
  114. X}
  115. X
  116. XKey makefunckey(fun) /**/
  117. Xint fun;
  118. X{
  119. XKey ky = zcalloc(sizeof *ky);
  120. X
  121. X    ky->func = fun;
  122. X    return ky;
  123. X}
  124. X
  125. X/* initialize the bindings */
  126. X
  127. Xvoid initxbindtab() /**/
  128. X{
  129. Xint t0,vi = 0;
  130. Xchar buf[3],*s;
  131. X
  132. X    lastnamed = z_undefinedkey;
  133. X    if (s = zgetenv("VISUAL"))
  134. X        {
  135. X        if (ztrstr(s,"vi"))
  136. X            vi = 1;
  137. X        }
  138. X    else if ((s = zgetenv("EDITOR")) && ztrstr(s,"vi"))
  139. X        vi = 1;
  140. X    if (vi)
  141. X        {
  142. X        for (t0 = 0; t0 != 32; t0++)
  143. X            mainbindtab[t0] = viinsbind[t0];
  144. X        for (t0 = 32; t0 != 256; t0++)
  145. X            mainbindtab[t0] = z_selfinsert;
  146. X        mainbindtab[127] = z_backwarddeletechar;
  147. X        }
  148. X    else
  149. X        {
  150. X        for (t0 = 0; t0 != 128; t0++)
  151. X            mainbindtab[t0] = emacsbind[t0];
  152. X        for (t0 = 128; t0 != 256; t0++)
  153. X            mainbindtab[t0] = z_selfinsert;
  154. X        }
  155. X    for (t0 = 0200; t0 != 0240; t0++)
  156. X        mainbindtab[t0] = z_undefinedkey;
  157. X    for (t0 = 0; t0 != 128; t0++)
  158. X        altbindtab[t0] = vicmdbind[t0];
  159. X    for (t0 = 128; t0 != 256; t0++)
  160. X        altbindtab[t0] = emacsbind[t0];
  161. X    bindtab = mainbindtab;
  162. X    kungetbuf = zalloc(kungetsz = 32);
  163. X    kungetct = 0;
  164. X    xbindtab = newhtable(67);
  165. X    addhperm("\33\133C",makefunckey(z_forwardchar),xbindtab,NULL);
  166. X    addhperm("\33\133D",makefunckey(z_backwardchar),xbindtab,NULL);
  167. X    addhperm("\33\133A",makefunckey(z_uplineorhistory),xbindtab,NULL);
  168. X    addhperm("\33\133B",makefunckey(z_downlineorhistory),xbindtab,NULL);
  169. X    addhperm("\30*",makefunckey(z_expandword),xbindtab,NULL);
  170. X    addhperm("\30g",makefunckey(z_listexpand),xbindtab,NULL);
  171. X    addhperm("\30G",makefunckey(z_listexpand),xbindtab,NULL);
  172. X    addhperm("\30\16",makefunckey(z_infernexthistory),xbindtab,NULL);
  173. X    addhperm("\30\13",makefunckey(z_killbuffer),xbindtab,NULL);
  174. X    addhperm("\30\6",makefunckey(z_vifindnextchar),xbindtab,NULL);
  175. X    addhperm("\30\17",makefunckey(z_overwritemode),xbindtab,NULL);
  176. X    addhperm("\30\25",makefunckey(z_undo),xbindtab,NULL);
  177. X    addhperm("\30\26",makefunckey(z_vicmdmode),xbindtab,NULL);
  178. X    addhperm("\30\12",makefunckey(z_vijoin),xbindtab,NULL);
  179. X    addhperm("\30\2",makefunckey(z_vimatchbracket),xbindtab,NULL);
  180. X    addhperm("\30s",makefunckey(z_historyincrementalsearchforward),
  181. X        xbindtab,NULL);
  182. X    addhperm("\30r",makefunckey(z_historyincrementalsearchbackward),
  183. X        xbindtab,NULL);
  184. X    addhperm("\30u",makefunckey(z_undo),xbindtab,NULL);
  185. X    addhperm("\30\30",makefunckey(z_exchangepointandmark),
  186. X        xbindtab,NULL);
  187. X    addhperm("run-help",mkanode(ztrdup("man"),1),aliastab,NULL);
  188. X    addhperm("which-command",mkanode(ztrdup("whence"),1),aliastab,NULL);
  189. X    strcpy(buf,"\33q");
  190. X    if (!vi)
  191. X        for (t0 = 128; t0 != 256; t0++)
  192. X            if (emacsbind[t0] != z_undefinedkey) {
  193. X                buf[1] = t0 & 0x7f;
  194. X                addhnode(ztrdup(buf),makefunckey(emacsbind[t0]),xbindtab,NULL);
  195. X            }
  196. X    for (t0 = 0; t0 != 36; t0++)
  197. X        vibuf[t0] = NULL;
  198. X    for (t0 = 0; t0 != 26; t0++)
  199. X        vimarkline[t0] = 0;
  200. X    stackhist = stackcs = -1;
  201. X    vichgbufsz = 0;
  202. X    vichgbuf = NULL;
  203. X}
  204. X
  205. Xchar *getkeystring(s,len) /**/
  206. Xchar *s;int *len;
  207. X{
  208. Xstatic char buf[512];
  209. Xchar *t = buf;
  210. Xint x,first = 1,metanext = 0;
  211. X
  212. X    for (;*s;s++)
  213. X        {
  214. X        if (*s == '\\' && s[1])
  215. X            switch(*++s)
  216. X                {
  217. X                case 'a': *t++ = '\07'; break;
  218. X                case 'n': *t++ = '\n'; break;
  219. X                case 'b': *t++ = '\010'; break;
  220. X                case 't': *t++ = '\t'; break;
  221. X                case 'v': *t++ = '\v'; break;
  222. X                case 'f': *t++ = '\f'; break;
  223. X                case 'r': *t++ = '\r'; break;
  224. X                case 'e': *t++ = '\033'; break;
  225. X                case 'M':
  226. X                    if (s[1] == '-')
  227. X                        s++;
  228. X                    metanext = 2;
  229. X                    break;
  230. X                default:
  231. X                    if (idigit(*s))
  232. X                        {
  233. X                        for (x = 0; idigit(*s); s++)
  234. X                            x = x*8+(*s-'0');
  235. X                        s--;
  236. X                        *t++ = x;
  237. X                        }
  238. X                    else
  239. X                        *t++ = *s;
  240. X                    break;
  241. X                }
  242. X        else if (*s == '^')
  243. X            if (*++s == '?')
  244. X                *t++ = 0x7f;
  245. X            else
  246. X                *t++ = *s & 0x9f;
  247. X        else
  248. X            *t++ = *s;
  249. X        if (metanext && !(--metanext))
  250. X            {
  251. X            t[-1] |= 0x80;
  252. X            metanext = 0;
  253. X            }
  254. X        if (t > buf+500)
  255. X            break;
  256. X        first = 0;
  257. X        }
  258. X    *t = '\0';
  259. X    *len = t-buf;
  260. X    return buf;
  261. X}
  262. X
  263. Xvoid printbind(s,len) /**/
  264. Xchar *s;int len;
  265. X{
  266. Xint ch;
  267. X
  268. X    while (len--)
  269. X        {
  270. X        ch = (unsigned char) *s++;
  271. X        if (ch & 0x80)
  272. X            {
  273. X            printf("\\M-");
  274. X            ch &= 0x7f;
  275. X            }
  276. X        if (icntrl(ch))
  277. X            switch(ch)
  278. X                {
  279. X                case 0x7f: printf("^?"); break;
  280. X                default: printf("^%c",(ch|0x40)); break;
  281. X                }
  282. X        else
  283. X            putchar(ch);
  284. X        }
  285. X}
  286. X
  287. Xvoid printbinding(str,k) /**/
  288. Xchar *str;Key k;
  289. X{
  290. X    if (k->func == z_sequenceleadin)
  291. X        return;
  292. X    putchar('\"');
  293. X    printbind(str,strlen(str));
  294. X    printf("\"\t");
  295. X    if (k->func == z_sendstring)
  296. X        {
  297. X        putchar('\"');
  298. X        printbind(k->str,k->len);
  299. X        printf("\"\n");
  300. X        }
  301. X    else
  302. X        printf("%s\n",zlecmds[k->func].name);
  303. X}
  304. X
  305. Xint bin_bindkey(name,argv,ops,junc) /**/
  306. Xchar *name;char **argv;char *ops;int junc;
  307. X{
  308. Xint t0,len;
  309. Xchar *s;
  310. Xint func,*tab;
  311. X
  312. X    tab = (ops['a']) ? altbindtab : mainbindtab;
  313. X    if (ops['v'] || ops['e'] || ops['d'])
  314. X        {
  315. X        if (*argv)
  316. X            {
  317. X            zerrnam(name,"too many arguments",NULL,0);
  318. X            return 1;
  319. X            }
  320. X        if (ops['d'] || ops['e'])
  321. X            if (ops['m'])
  322. X                for (t0 = 0; t0 != 256; t0++)
  323. X                    tab[t0] = emacsbind[t0];
  324. X            else
  325. X                {
  326. X                for (t0 = 0; t0 != 128; t0++)
  327. X                    tab[t0] = emacsbind[t0];
  328. X                for (t0 = 128; t0 != 256; t0++)
  329. X                    tab[t0] = z_selfinsert;
  330. X                }
  331. X        else
  332. X            {
  333. X            for (t0 = 0; t0 != 32; t0++)
  334. X                mainbindtab[t0] = viinsbind[t0];
  335. X            for (t0 = 32; t0 != 256; t0++)
  336. X                mainbindtab[t0] = z_selfinsert;
  337. X            mainbindtab[127] = z_backwarddeletechar;
  338. X            }
  339. X        for (t0 = 0; t0 != 128; t0++)
  340. X            altbindtab[t0] = vicmdbind[t0];
  341. X        for (t0 = 128; t0 != 256; t0++)
  342. X            altbindtab[t0] = emacsbind[t0];
  343. X        for (t0 = 0200; t0 != 0240; t0++)
  344. X            tab[t0] = z_undefinedkey;
  345. X        return 0;
  346. X        }
  347. X    if (!*argv)
  348. X        {
  349. X        char buf[2];
  350. X        
  351. X        buf[0] = 'x'; buf[1] = '\0';
  352. X        for (t0 = 0; t0 != 256; t0++)
  353. X            {
  354. X            buf[0] = t0;
  355. X            putchar('\"');
  356. X            printbind(buf,1);
  357. X            if (t0 < 254 && tab[t0] == tab[t0+1] && tab[t0] == tab[t0+2])
  358. X                {
  359. X                printf("\" to \"");
  360. X                while (tab[t0] == tab[t0+1]) t0++;
  361. X                buf[0] = t0;
  362. X                printbind(buf,1);
  363. X                }
  364. X            printf("\"\t%s\n",zlecmds[tab[t0]].name);
  365. X            }
  366. X        listhtable(xbindtab,(HFunc) printbinding);
  367. X        return 0;
  368. X        }
  369. X    while (*argv)
  370. X        {
  371. X        s = getkeystring(*argv++,&len);
  372. X        if (len > 8)
  373. X            {
  374. X            zerrnam(name,"in-string too long",NULL,0);
  375. X            return 1;
  376. X            }
  377. X        if (!*argv || ops['r'])
  378. X            {
  379. X            Key ky;
  380. X
  381. X            ky = gethnode(s,xbindtab);
  382. X            if (len == 1)
  383. X                func = tab[(unsigned char) *s];
  384. X            else
  385. X                func = (ky) ? ky->func : z_undefinedkey;
  386. X            if (func == z_undefinedkey)
  387. X                {
  388. X                zerrnam(name,"in-string is not bound",NULL,0);
  389. X                return 1;
  390. X                }
  391. X            if (ops['r'])
  392. X                {
  393. X                if (len == 1)
  394. X                    tab[(unsigned char) *s] = z_undefinedkey;
  395. X                else
  396. X                    {
  397. X                    while (strlen(s) > 1)
  398. X                        {
  399. X                        free(remhnode(s,xbindtab));
  400. X                        s[strlen(s)-1] = '\0';
  401. X                        }
  402. X                    }
  403. X                continue;
  404. X                }
  405. X            if (func == z_sendstring)
  406. X                {
  407. X                printbind(ky->str,ky->len);
  408. X                putchar('\n');
  409. X                return 0;
  410. X                }
  411. X            printf("%s\n",zlecmds[func].name);
  412. X            return 0;
  413. X            }
  414. X        if (!ops['s'])
  415. X            {
  416. X            for (t0 = 0; t0 != ZLECMDCOUNT; t0++)
  417. X                if (!strcmp(*argv,zlecmds[t0].name))
  418. X                    break;
  419. X            if (t0 == ZLECMDCOUNT)
  420. X                {
  421. X                zerr("undefined function: %s",*argv,0);
  422. X                return 1;
  423. X                }
  424. X            func = t0;
  425. X            }
  426. X        else
  427. X            func = z_sendstring;
  428. X        if (len == 1)
  429. X            {
  430. X            Key ky;
  431. X
  432. X            tab[(unsigned char) *s] = (ops['s']) ? z_sendstring : t0;
  433. X            if (ops['s'])
  434. X                {
  435. X                addhnode(ztrdup(s),ky = makefunckey(z_sendstring),xbindtab,freekey);
  436. X                ky->str = ztrdup(getkeystring(*argv,&ky->len));
  437. X                }
  438. X            }
  439. X        else
  440. X            {
  441. X            int t1;
  442. X            Key ky;
  443. X
  444. X            if (tab[(unsigned char) *s] != z_undefinedkey &&
  445. X                    tab[(unsigned char) *s] != z_sequenceleadin)
  446. X                {
  447. X                zerrnam(name,"in-string has already bound prefix",NULL,0);
  448. X                return 1;
  449. X                }
  450. X            tab[(unsigned char) *s] = z_sequenceleadin;
  451. X            if (!s[1])
  452. X                s[1] = 0x80;
  453. X            for (t1 = 1; t1 != len-1; t1++)
  454. X                {
  455. X                char sav;
  456. X
  457. X                sav = s[t1+1];
  458. X                s[t1+1] = '\0';
  459. X                ky = gethnode(s,xbindtab);
  460. X                if (ky && ky->func != z_sequenceleadin)
  461. X                    {
  462. X                    zerrnam(name,"in-string has already bound prefix",NULL,0);
  463. X                    return 1;
  464. X                    }
  465. X                if (!ky)
  466. X                    addhnode(ztrdup(s),makefunckey(z_sequenceleadin),xbindtab,
  467. X                        freekey);
  468. X                if (!sav)
  469. X                    sav = 0x80;
  470. X                s[t1+1] = sav;
  471. X                }
  472. X            addhnode(ztrdup(s),ky = makefunckey(func),xbindtab,freekey);
  473. X            if (ops['s'])
  474. X                ky->str = ztrdup(getkeystring(*argv,&ky->len));
  475. X            }
  476. X        argv++;
  477. X        }
  478. X    return 0;
  479. X}
  480. X
  481. Xvoid freekey(x) /**/
  482. Xvptr x;
  483. X{
  484. XKey k = x;
  485. X
  486. X    if (k->str)
  487. X        free(k->str);
  488. X    free(k);
  489. X}
  490. X
  491. X/* this is mostly stolen from bash's draino() */
  492. X
  493. Xvoid drainoutput() /**/
  494. X{
  495. Xint n = 0;
  496. X
  497. X    if (!baud) return;
  498. X#ifdef TIOCOUTQ
  499. X#ifdef HAS_SELECT
  500. X    while ((ioctl(SHTTY,TIOCOUTQ,&n) >= 0) && n) {
  501. X        struct timeval tv;
  502. X        tv.tv_sec = n/baud;
  503. X        tv.tv_usec = ((n%baud)*1000000)/baud;
  504. X        select (0,(fd_set *)0,(fd_set *)0,(fd_set *)0,&tv);
  505. X    }
  506. X#endif
  507. X#endif
  508. X}
  509. X
  510. SHAR_EOF
  511. echo 'File zsh2.1/src/zle_main.c is complete' &&
  512. chmod 0644 zsh2.1/src/zle_main.c ||
  513. echo 'restore of zsh2.1/src/zle_main.c failed'
  514. Wc_c="`wc -c < 'zsh2.1/src/zle_main.c'`"
  515. test 14557 -eq "$Wc_c" ||
  516.     echo 'zsh2.1/src/zle_main.c: original size 14557, current size' "$Wc_c"
  517. rm -f _shar_wnt_.tmp
  518. fi
  519. # ============= zsh2.1/src/zle_refresh.c ==============
  520. if test -f 'zsh2.1/src/zle_refresh.c' -a X"$1" != X"-c"; then
  521.     echo 'x - skipping zsh2.1/src/zle_refresh.c (File already exists)'
  522.     rm -f _shar_wnt_.tmp
  523. else
  524. > _shar_wnt_.tmp
  525. echo 'x - extracting zsh2.1/src/zle_refresh.c (Text)'
  526. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.1/src/zle_refresh.c' &&
  527. X/*
  528. X
  529. X    zle_refresh.c - screen update
  530. X
  531. X    This file is part of zsh, the Z shell.
  532. X
  533. X    zsh is free software; no one can prevent you from reading the source
  534. X   code, or giving it to someone else.
  535. X
  536. X   This file is copyrighted under the GNU General Public License, which
  537. X   can be found in the file called COPYING.
  538. X
  539. X   Copyright (C) 1990, 1991 Paul Falstad
  540. X
  541. X   zsh is distributed in the hope that it will be useful, but
  542. X   WITHOUT ANY WARRANTY.  No author or distributor accepts
  543. X   responsibility to anyone for the consequences of using it or for
  544. X   whether it serves any particular purpose or works at all, unless he
  545. X   says so in writing.  Refer to the GNU General Public License
  546. X   for full details.
  547. X
  548. X   Everyone is granted permission to copy, modify and redistribute
  549. X   zsh, but only under the conditions described in the GNU General Public
  550. X   License.   A copy of this license is supposed to have been given to you
  551. X   along with zsh so you can know your rights and responsibilities.
  552. X   It should be in a file named COPYING.
  553. X
  554. X   Among other things, the copyright notice and this notice must be
  555. X   preserved on all copies.
  556. X
  557. X*/
  558. X
  559. X#define ZLE
  560. X#include "zsh.h"
  561. X
  562. Xchar **obuf = NULL,**nbuf = NULL;
  563. Xint olnct,nlnct;
  564. Xint winw,winh,winpos;
  565. X
  566. Xint vcs,vln,vmaxln;
  567. X
  568. X#define nextline { *s = '\0'; \
  569. X    if (winh == ln+1) if (nvln != -1) break; else ln = scrollwindow()-1; \
  570. X    s = nbuf[++ln]; sen = s+winw; \
  571. X    }
  572. X
  573. Xvoid resetvideo() /**/
  574. X{
  575. Xint ln;
  576. Xstatic int lwinw = -1,lwinh = -1;
  577. X
  578. X    setterm();
  579. X    winw = columns-1;
  580. X    if (isset(SINGLELINEZLE) || !termok)
  581. X        winh = 1;
  582. X    else
  583. X        winh = (lines < 2) ? 24 : lines;
  584. X    winpos = vln = vmaxln = 0;
  585. X    if (lwinw != winw || lwinh != winh)
  586. X        {
  587. X        if (nbuf)
  588. X            {
  589. X            for (ln = 0; ln != lwinh; ln++)
  590. X                {
  591. X                free(nbuf[ln]);
  592. X                free(obuf[ln]);
  593. X                }
  594. X            free(nbuf);
  595. X            free(obuf);
  596. X            }
  597. X        nbuf = (char **) zalloc((winh+1)*sizeof(char *));
  598. X        obuf = (char **) zalloc((winh+1)*sizeof(char *));
  599. X        for (ln = 0; ln != winh+1; ln++)
  600. X            {
  601. X            nbuf[ln] = zalloc(winw+1);
  602. X            obuf[ln] = zalloc(winw+1);
  603. X            }
  604. X        lwinw = winw;
  605. X        lwinh = winh;
  606. X        }
  607. X    for (ln = 0; ln != winh+1; ln++)
  608. X        {
  609. X        *nbuf[ln] = '\0';
  610. X        *obuf[ln] = '\0';
  611. X        }
  612. X    if (!pptlen)
  613. X        nbuf[0][0] = obuf[0][0] = '\0';
  614. X    else
  615. X        {
  616. X        for (ln = 0; ln != pptlen-1; ln++)
  617. X            nbuf[0][ln] = obuf[0][ln] = ' ';
  618. X        nbuf[0][ln] = obuf[0][ln] = '>';
  619. X        nbuf[0][pptlen] = obuf[0][pptlen] = '\0';
  620. X        }
  621. X    vcs = pptlen;
  622. X    olnct = nlnct = 1;
  623. X}
  624. X
  625. Xint scrollwindow() /**/
  626. X{
  627. Xint t0,hwinh = winh/2;
  628. X
  629. X    for (t0 = 0; t0 != winh-hwinh; t0++)
  630. X        {
  631. X        char *s;
  632. X
  633. X        s = nbuf[t0];
  634. X        nbuf[t0] = nbuf[t0+hwinh];
  635. X        nbuf[t0+hwinh] = s;
  636. X        }
  637. X    for (t0 = 0; t0 != pptlen-1; t0++)
  638. X        nbuf[0][t0] = ' ';
  639. X    strcpy(nbuf[0]+t0,"> ...");
  640. X    return winh-hwinh;
  641. X}
  642. X
  643. X/* this is the messy part. */
  644. X
  645. Xvoid refresh() /**/
  646. X{
  647. Xchar *s,*t,*sen,*scs = line+cs,**qbuf;
  648. Xint ln = 0,nvcs,nvln = -1,t0;
  649. X
  650. X    cost = 0;
  651. X    if (resetneeded)
  652. X        {
  653. X        resetvideo();
  654. X        resetneeded = 0;
  655. X        if (isset(SINGLELINEZLE) || !termok)
  656. X            vcs = 0;
  657. X        else
  658. X            printf("%s",pmpt);
  659. X        }
  660. X    if (isset(SINGLELINEZLE) || !termok)
  661. X        {
  662. X        singlerefresh();
  663. X        return;
  664. X        }
  665. X
  666. X/* first, we generate the video line buffers so we know what to
  667. X    put on the screen. 
  668. X
  669. X    s = ptr into the video buffer.
  670. X    t = ptr into the real buffer.
  671. X    sen = end of the video buffer (eol)
  672. X*/
  673. X
  674. X    s = nbuf[ln = 0]+pptlen;
  675. X    t = line;
  676. X    sen = *nbuf+winw;
  677. X    for (; *t; t++)
  678. X        {
  679. X        if (icntrl(*t))
  680. X            if (*t == '\n')
  681. X                {
  682. X                if (t == scs)
  683. X                    {
  684. X                    nvcs = s-nbuf[nvln = ln];
  685. X                    scs = NULL;
  686. X                    }
  687. X                nextline
  688. X                }
  689. X            else if (*t == '\t')
  690. X                {
  691. X                int t1 = s-nbuf[ln];
  692. X
  693. X                if ((t1|7)+1 >= winw) nextline
  694. X                else
  695. X                    do
  696. X                        *s++ = ' ';
  697. X                    while ((++t1) & 7);
  698. X                }
  699. X            else
  700. X                {
  701. X                if (s == sen) nextline
  702. X                *s++ = '^';
  703. X                if (s == sen) nextline
  704. X                *s++ = (*t == 127) ? '?' : (*t | '@');
  705. X                }
  706. X        else
  707. X            {
  708. X            if (s == sen) nextline
  709. X            *s++ = *t;
  710. X            }
  711. X/* if the cursor is here, remember it */
  712. X
  713. X        if (t == scs)
  714. X            nvcs = s-nbuf[nvln = ln]-1;
  715. X        }
  716. X    if (scs == t)
  717. X        nvcs = s-nbuf[nvln = ln];
  718. X    *s = '\0';
  719. X    nlnct = ln+1;
  720. X    if (statusline)
  721. X        strcpy(nbuf[(nlnct == winh) ? winh-1 : nlnct++],statusline);
  722. X
  723. X/* do RPROMPT */
  724. X
  725. X    if (pmpt2 && ln == 0 && strlen(nbuf[0])+strlen(pmpt2) < winw)
  726. X        {
  727. X        for (t0 = strlen(nbuf[0]); t0 != winw; t0++)
  728. X            nbuf[0][t0] = ' ';
  729. X        strcpy(nbuf[0]+winw-strlen(pmpt2),pmpt2);
  730. X        }
  731. X    for (ln = 0; ln < nlnct; ln++)
  732. X        {
  733. X
  734. X/* if old line and new line are different,
  735. X    see if we can insert/delete a line */
  736. X
  737. X        if (ln < olnct && strncmp(nbuf[ln],obuf[ln],16))
  738. X            {
  739. X            if (tccan(TCDELLINE) && !strncmp(nbuf[ln],obuf[ln+1],16)
  740. X                    && obuf[ln+1][0] && ln != olnct)
  741. X                {
  742. X                int t0;
  743. X
  744. X                moveto(ln,0);
  745. X                tcout(TCDELLINE);
  746. X                for (t0 = ln; t0 != olnct; t0++)
  747. X                    strcpy(obuf[t0],obuf[t0+1]);
  748. X                olnct--;
  749. X                }
  750. X
  751. X/* don't try to insert a line if olnct < vmaxln (vmaxln is the number
  752. X    of lines that have been displayed by this routine) so that we don't
  753. X    go off the end of the screen. */
  754. X
  755. X            else if (tccan(TCINSLINE) && !strncmp(nbuf[ln+1],obuf[ln],16) &&
  756. X                    olnct < vmaxln && nbuf[ln+1][0] && ln != olnct)
  757. X                {
  758. X                int t0;
  759. X
  760. X                moveto(ln,0);
  761. X                tcout(TCINSLINE);
  762. X                for (t0 = olnct; t0 != ln; t0--)
  763. X                    strcpy(obuf[t0],obuf[t0-1]);
  764. X                *obuf[ln] = '\0';
  765. X                olnct++;
  766. X                }
  767. X            }
  768. X        refreshline(ln);
  769. X        }
  770. X
  771. X/* if old buffer had extra lines, do a clear-end-of-display if we can,
  772. X    otherwise, just fill new buffer with blank lines and refresh them */
  773. X
  774. X    if (olnct > nlnct)
  775. X        {
  776. X        for (ln = nlnct; ln < olnct; ln++)
  777. X            nbuf[ln][0] = '\0';
  778. X        if (tccan(TCCLEAREOD))
  779. X            {
  780. X            moveto(nlnct,0);
  781. X            tcout(TCCLEAREOD);
  782. X            }
  783. X        else
  784. X            for (ln = nlnct; ln < olnct; ln++)
  785. X                refreshline(ln);
  786. X        }
  787. X
  788. X/* move to the new cursor position */
  789. X
  790. X    moveto(nvln,nvcs);
  791. X    qbuf = nbuf;
  792. X    nbuf = obuf;
  793. X    obuf = qbuf;
  794. X    olnct = nlnct;
  795. X    if (nlnct > vmaxln)
  796. X        vmaxln = nlnct;
  797. X    fflush(stdout);
  798. X}
  799. X
  800. X#define tcinscost(X) (tccan(TCMULTINS) ? tclen[TCMULTINS] : (X)*tclen[TCINS])
  801. X#define tcdelcost(X) (tccan(TCMULTDEL) ? tclen[TCMULTDEL] : (X)*tclen[TCDEL])
  802. X#define tc_delchars(X) tcmultout(TCDEL,TCMULTDEL,(X))
  803. X#define tc_inschars(X) tcmultout(TCINS,TCMULTINS,(X))
  804. X#define tc_upcurs(X) tcmultout(TCUP,TCMULTUP,(X))
  805. X#define tc_leftcurs(X) tcmultout(TCLEFT,TCMULTLEFT,(X))
  806. X
  807. Xvoid refreshline(ln) /**/
  808. Xint ln;
  809. X{
  810. Xchar *nl = nbuf[ln],*ol = obuf[ln];
  811. Xchar *p1;
  812. Xint ccs = 0;
  813. X
  814. X    if (ln >= olnct)
  815. X        *ol = '\0';
  816. X    for (;;)
  817. X        {
  818. X        while (*nl && *nl == *ol)
  819. X            {
  820. X            nl++,ol++,ccs++;
  821. X            }
  822. X        if (!*nl && !*ol)
  823. X            return;
  824. X
  825. X/* if this is the end of the new buffer but the old buffer has stuff
  826. X    here, clear to end of line if we can, otherwise fill the new buffer
  827. X    with blanks and continue. */
  828. X
  829. X        if (!*nl)
  830. X            {
  831. X            if (tccan(TCCLEAREOL) && strlen(ol) > tclen[TCCLEAREOL])
  832. X                {
  833. X                moveto(ln,ccs);
  834. X                tcout(TCCLEAREOL);
  835. X                *ol = '\0';
  836. X                return;
  837. X                }
  838. X            else
  839. X                {
  840. X                int x = strlen(ol);
  841. X                char *p = nl;
  842. X
  843. X                while (x--)
  844. X                    *p++ = ' ';
  845. X                *p = '\0';
  846. X                continue;
  847. X                }
  848. X            }
  849. X
  850. X/* if this is the end of the old buffer, just dump the rest of the
  851. X    new buffer. */
  852. X
  853. X        if (!*ol)
  854. X            {
  855. X            while (*nl == ' ')
  856. X                nl++,ccs++;
  857. X            if (*nl)
  858. X                {
  859. X                moveto(ln,ccs);
  860. X                fwrite(nl,strlen(nl),1,stdout);
  861. X                cost += strlen(nl);
  862. X                ccs = (vcs += strlen(nl));
  863. X                }
  864. X            return;
  865. X            }
  866. X        moveto(ln,ccs);
  867. X
  868. X/* try to insert/delete characters */
  869. X
  870. X        if (ol[1] != nl[1] && tccan(TCDEL))
  871. X            {
  872. X            int ct = 0;
  873. X
  874. X            for (p1 = ol; *p1; p1++,ct++)
  875. X                if (tcdelcost(ct) < streqct(p1,nl))
  876. X                    {
  877. X                    tc_delchars(ct);
  878. X                    ol = p1;
  879. X                    break;
  880. X                    }
  881. X            if (*p1)
  882. X                continue;
  883. X            }
  884. X
  885. X        if (ol[1] != nl[1] && tccan(TCINS))
  886. X            {
  887. X            int ct = 0;
  888. X
  889. X            for (p1 = nl; *p1; p1++,ct++)
  890. X                if (tcinscost(ct) < streqct(p1,ol)+ct)
  891. X                    {
  892. X/* make sure we aren't inserting characters off the end of the screen;
  893. X    if we are, jump to the end and truncate the line, if we can do
  894. X    it quickly */
  895. X
  896. X                    if (ct+ccs+strlen(ol) >= winw-1)
  897. X                        {
  898. X                        if (!tccan(TCMULTRIGHT) || ccs > winw-tclen[TCMULTRIGHT])
  899. X                            continue;
  900. X                        moveto(ln,winw-1-ct);
  901. X                        if (!tccan(TCCLEAREOL) || ct < tclen[TCCLEAREOL])
  902. X                            {
  903. X                            int x = ct;
  904. X
  905. X                            while (vcs++,x--)
  906. X                                putchar(' ');
  907. X                            }
  908. X                        else
  909. X                            tcout(TCCLEAREOL);
  910. X                        moveto(ln,ccs);
  911. X                        }
  912. X                    if (ct+ccs+strlen(ol) < winw-1)
  913. X                        {
  914. X                        tc_inschars(ct = p1-nl);
  915. X                        ccs = (vcs += p1-nl);
  916. X                        cost += ct;
  917. X                        fwrite(nl,ct,1,stdout);
  918. X                        nl += ct;
  919. X                        break;
  920. X                        }
  921. X                    }
  922. X            if (*p1)
  923. X                continue;
  924. X            }
  925. X
  926. X/* if we can't do anything fancy, just write the new character and
  927. X    keep going. */
  928. X
  929. X        putchar(*nl);
  930. X        cost++;
  931. X        nl++,ol++,ccs = ++vcs;
  932. X        }
  933. X}
  934. X
  935. Xvoid moveto(ln,cl) /**/
  936. Xint ln;int cl;
  937. X{
  938. X
  939. X/* move up */
  940. X
  941. X    if (ln < vln)
  942. X        {
  943. X        tc_upcurs(vln-ln);
  944. X        vln = ln;
  945. X        }
  946. X
  947. X/* move down; if we might go off the end of the screen, use newlines
  948. X    instead of TCDOWN */
  949. X
  950. X    while (ln > vln)
  951. X        if (cl < (vcs/2) || ln >= vmaxln || !tccan(TCLEFT))
  952. X            {
  953. X            putchar('\r');
  954. X            putchar('\n');
  955. X            cost+=2;
  956. X            vln++;
  957. X            vcs = 0;
  958. X            }
  959. X        else
  960. X            {
  961. X            tc_downcurs(ln-vln);
  962. X            vln = ln;
  963. X            }
  964. X    if (cl < (vcs/2) || !tccan(TCLEFT))
  965. X        {
  966. X        putchar('\r');
  967. X        cost++;
  968. X        vcs = 0;
  969. X        }
  970. X    if (vcs < cl)
  971. X        tc_rightcurs(cl-vcs);
  972. X    else if (vcs > cl)
  973. X        tc_leftcurs(vcs-cl);
  974. X    vcs = cl;
  975. X}
  976. X
  977. Xvoid tcmultout(cap,multcap,ct) /**/
  978. Xint cap;int multcap;int ct;
  979. X{
  980. X    if (tccan(multcap) && (!tccan(cap) || tclen[multcap] < tclen[cap]*ct))
  981. X        tcoutarg(multcap,ct);
  982. X    else while (ct--)
  983. X        tcout(cap);
  984. X}
  985. X
  986. Xvoid tc_rightcurs(ct) /**/
  987. Xint ct;
  988. X{
  989. X
  990. X/* do a multright if it's cheaper or if we're walking over the prompt.  */
  991. X
  992. X    if (tccan(TCMULTRIGHT) &&
  993. X            (ct > tclen[TCMULTRIGHT] || vln == 0 && vcs < pptlen))
  994. X        tcoutarg(TCMULTRIGHT,ct);
  995. X
  996. X/* if we're walking over the prompt and we can do a bunch of cursor rights,
  997. X    do them, even though they're more expensive.  (We can't redraw the
  998. X    prompt very easily in general.)  */
  999. X
  1000. X    else if (vln == 0 && vcs < pptlen && tccan(TCRIGHT))
  1001. X        while (ct--)
  1002. X            tcout(TCRIGHT);
  1003. X
  1004. X/* otherwise write the contents of the video buffer. */
  1005. X
  1006. X    else
  1007. X        fwrite(nbuf[vln]+vcs,ct,1,stdout);
  1008. X}
  1009. X
  1010. Xvoid tc_downcurs(ct) /**/
  1011. Xint ct;
  1012. X{
  1013. X    if (tccan(TCMULTDOWN) &&
  1014. X            (!tccan(TCDOWN) || tclen[TCMULTDOWN] < tclen[TCDOWN]*ct))
  1015. X        tcoutarg(TCMULTDOWN,ct);
  1016. X    else if (tccan(TCDOWN))
  1017. X        while (ct--)
  1018. X            tcout(TCDOWN);
  1019. X    else
  1020. X        {
  1021. X        while (ct--)
  1022. X            putchar('\n');
  1023. X        vcs = 0;
  1024. X        }
  1025. X}
  1026. X
  1027. X/* I'm NOT going to worry about padding unless anyone complains. */
  1028. X
  1029. Xvoid tcout(cap) /**/
  1030. Xint cap;
  1031. X{
  1032. X    tputs(tcstr[cap],1,putraw);
  1033. X}
  1034. X
  1035. Xvoid tcoutarg(cap,arg) /**/
  1036. Xint cap;int arg;
  1037. X{
  1038. X    tputs(tgoto(tcstr[cap],arg,arg),1,putraw);
  1039. X}
  1040. X
  1041. Xvoid clearscreen() /**/
  1042. X{
  1043. X    tcout(TCCLEARSCREEN);
  1044. X    resetneeded = 1;
  1045. X}
  1046. X
  1047. Xvoid redisplay() /**/
  1048. X{
  1049. X    trashzle();
  1050. X}
  1051. X
  1052. Xvoid trashzle() /**/
  1053. X{
  1054. X    if (zleactive)
  1055. X        {
  1056. X        refresh();
  1057. X        moveto(nlnct,0);
  1058. X        fflush(stdout);
  1059. X        unsetterm();
  1060. X        resetneeded = 1;
  1061. X        }
  1062. X}
  1063. X
  1064. Xvoid singlerefresh() /**/
  1065. X{
  1066. Xchar *vbuf,*vp,**qbuf,*op;
  1067. Xint t0,vsiz,nvcs;
  1068. X
  1069. X    for (vsiz = 1+pptlen, t0 = 0; t0 != ll; t0++,vsiz++)
  1070. X        if (line[t0] == '\t')
  1071. X            vsiz += 7;
  1072. X        else if (icntrl(line[t0]))
  1073. X            vsiz++;
  1074. X    vbuf = zalloc(vsiz);
  1075. X    strcpy(vbuf,pmpt);
  1076. X    vp = vbuf+pptlen;
  1077. X    for (t0 = 0; t0 != ll; t0++)
  1078. X        {
  1079. X        if (line[t0] == '\t')
  1080. X            do
  1081. X                *vp++ = ' ';
  1082. X            while ((vp-vbuf) & 7);
  1083. X        else if (line[t0] == '\n')
  1084. X            {
  1085. X            *vp++ = '\\';
  1086. X            *vp++ = 'n';
  1087. X            }
  1088. X        else if (line[t0] == 0x7f)
  1089. X            {
  1090. X            *vp++ = '^';
  1091. X            *vp++ = '?';
  1092. X            }
  1093. X        else if (icntrl(line[t0]))
  1094. X            {
  1095. X            *vp++ = '^';
  1096. X            *vp++ = line[t0] | '@';
  1097. X            }
  1098. X        else
  1099. X            *vp++ = line[t0];
  1100. X        if (t0 == cs)
  1101. X            nvcs = vp-vbuf-1;
  1102. X        }
  1103. X    if (t0 == cs)
  1104. X        nvcs = vp-vbuf;
  1105. X    *vp = '\0';
  1106. X    if ((winpos && nvcs < winpos+1) || (nvcs > winpos+winw-1))
  1107. X        {
  1108. X        if ((winpos = nvcs-(winw/2)) < 0)
  1109. X            winpos = 0;
  1110. X        }
  1111. X    if (winpos)
  1112. X        vbuf[winpos] = '<';
  1113. X    if (strlen(vbuf+winpos) > winw)
  1114. X        {
  1115. X        vbuf[winpos+winw-1] = '>';
  1116. X        vbuf[winpos+winw] = '\0';
  1117. X        }
  1118. X    strcpy(nbuf[0],vbuf+winpos);
  1119. X    free(vbuf);
  1120. X    nvcs -= winpos;
  1121. X    for (t0 = 0,vp = *nbuf,op = *obuf; *vp; t0++,vp++)
  1122. X        {
  1123. X        if (*vp != *op && !(*vp == ' ' && !*op))
  1124. X            {
  1125. X            singmoveto(t0);
  1126. X            putchar(*vp);
  1127. X            vcs++;
  1128. X            }
  1129. X        if (*op)
  1130. X            op++;
  1131. X        }
  1132. X    if (*op)
  1133. X        {
  1134. X        singmoveto(t0);
  1135. X        for (; *op; op++)
  1136. X            {
  1137. X            putchar(' ');
  1138. X            vcs++;
  1139. X            }
  1140. X        }
  1141. X    singmoveto(nvcs);
  1142. X    qbuf = nbuf;
  1143. X    nbuf = obuf;
  1144. X    obuf = qbuf;
  1145. X    fflush(stdout);
  1146. X}
  1147. X
  1148. Xvoid singmoveto(pos) /**/
  1149. Xint pos;
  1150. X{
  1151. X    while (pos < vcs)
  1152. X        {
  1153. X        vcs--;
  1154. X        putchar('\b');
  1155. X        }
  1156. X    while (pos > vcs)
  1157. X        {
  1158. X        putchar(nbuf[0][vcs]);
  1159. X        vcs++;
  1160. X        }
  1161. X}
  1162. X
  1163. Xint streqct(s,t) /**/
  1164. Xchar *s;char *t;
  1165. X{
  1166. Xint ct = 0;
  1167. X
  1168. X    while (*s && *s == *t) s++,t++,ct++;
  1169. X    return ct;
  1170. X}
  1171. X
  1172. SHAR_EOF
  1173. chmod 0644 zsh2.1/src/zle_refresh.c ||
  1174. echo 'restore of zsh2.1/src/zle_refresh.c failed'
  1175. Wc_c="`wc -c < 'zsh2.1/src/zle_refresh.c'`"
  1176. test 12102 -eq "$Wc_c" ||
  1177.     echo 'zsh2.1/src/zle_refresh.c: original size 12102, current size' "$Wc_c"
  1178. rm -f _shar_wnt_.tmp
  1179. fi
  1180. # ============= zsh2.1/src/zle_utils.c ==============
  1181. if test -f 'zsh2.1/src/zle_utils.c' -a X"$1" != X"-c"; then
  1182.     echo 'x - skipping zsh2.1/src/zle_utils.c (File already exists)'
  1183.     rm -f _shar_wnt_.tmp
  1184. else
  1185. > _shar_wnt_.tmp
  1186. echo 'x - extracting zsh2.1/src/zle_utils.c (Text)'
  1187. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.1/src/zle_utils.c' &&
  1188. X/*
  1189. X
  1190. X    zle_utils.c - miscellaneous line editor utilities
  1191. X
  1192. X    This file is part of zsh, the Z shell.
  1193. X
  1194. X    zsh is free software; no one can prevent you from reading the source
  1195. X   code, or giving it to someone else.
  1196. X
  1197. X   This file is copyrighted under the GNU General Public License, which
  1198. X   can be found in the file called COPYING.
  1199. X
  1200. X   Copyright (C) 1990, 1991 Paul Falstad
  1201. X
  1202. X   zsh is distributed in the hope that it will be useful, but
  1203. X   WITHOUT ANY WARRANTY.  No author or distributor accepts
  1204. X   responsibility to anyone for the consequences of using it or for
  1205. X   whether it serves any particular purpose or works at all, unless he
  1206. X   says so in writing.  Refer to the GNU General Public License
  1207. X   for full details.
  1208. X
  1209. X   Everyone is granted permission to copy, modify and redistribute
  1210. X   zsh, but only under the conditions described in the GNU General Public
  1211. X   License.   A copy of this license is supposed to have been given to you
  1212. X   along with zsh so you can know your rights and responsibilities.
  1213. X   It should be in a file named COPYING.
  1214. X
  1215. X   Among other things, the copyright notice and this notice must be
  1216. X   preserved on all copies.
  1217. X
  1218. X*/
  1219. X
  1220. X#define ZLE
  1221. X#include "zsh.h"
  1222. X
  1223. X/* make sure that the line buffer has at least sz chars */
  1224. X
  1225. Xvoid sizeline(sz) /**/
  1226. Xint sz;
  1227. X{
  1228. X    while (sz > linesz)
  1229. X        line = realloc(line,(linesz *= 4)+1);
  1230. X}
  1231. X
  1232. X/* insert space for ct chars at cursor position */
  1233. X
  1234. Xvoid spaceinline(ct) /**/
  1235. Xint ct;
  1236. X{
  1237. Xint i;
  1238. X
  1239. X    while (ct+ll > linesz)
  1240. X        line = realloc(line,(linesz *= 4)+1);
  1241. X    for (i = ll; i >= cs; i--)
  1242. X        line[i+ct] = line[i];
  1243. X    ll += ct;
  1244. X    line[ll] = '\0';
  1245. X}
  1246. X
  1247. Xvoid backkill(ct,dir) /**/
  1248. Xint ct;int dir;
  1249. X{
  1250. Xint i = (cs -= ct);
  1251. X
  1252. X    cut(i,ct,dir);
  1253. X    while (line[i] = line[i+ct])
  1254. X        i++;
  1255. X    ll -= ct;
  1256. X}
  1257. X
  1258. Xvoid forekill(ct,dir) /**/
  1259. Xint ct;int dir;
  1260. X{
  1261. Xint i = cs;
  1262. X
  1263. X    cut(i,ct,dir);
  1264. X    while (line[i] = line[i+ct])
  1265. X        i++;
  1266. X    ll -= ct;
  1267. X}
  1268. X
  1269. Xvoid cut(i,ct,dir) /**/
  1270. Xint i;int ct;int dir;
  1271. X{
  1272. X    if (vibufspec) {
  1273. X        int owrite = 1;
  1274. X        if (vibufspec >= 'A' && vibufspec <= 'Z') {
  1275. X            owrite = 0; vibufspec = tolower(vibufspec);
  1276. X        }
  1277. X        vibufspec += (idigit(vibufspec)) ? - '1' +26 : - 'a';
  1278. X        if (owrite || !vibuf[vibufspec]) {
  1279. X            if (vibuf[vibufspec]) free(vibuf[vibufspec]);
  1280. X            vibuf[vibufspec] = zalloc(ct+1);
  1281. X            ztrncpy(vibuf[vibufspec],line+i,ct);
  1282. X        } else {
  1283. X            int len = strlen(vibuf[vibufspec]);
  1284. X            vibuf[vibufspec] = realloc(vibuf[vibufspec],ct+len);
  1285. X            ztrncpy(vibuf[vibufspec]+len,line+i,ct);
  1286. X        }
  1287. X        vibufspec = 0;
  1288. X        return;
  1289. X    }
  1290. X    if (!cutbuf)
  1291. X        cutbuf = ztrdup("");
  1292. X    else if (!(lastcmd & ZLE_KILL)) {
  1293. X        kringnum = (kringnum+1)&(KRINGCT-1);
  1294. X        if (kring[kringnum])
  1295. X            free(kring[kringnum]);
  1296. X        kring[kringnum] = cutbuf;
  1297. X        cutbuf = ztrdup("");
  1298. X    }
  1299. X    if (dir) {
  1300. X        char *s = zalloc(strlen(cutbuf)+ct+1);
  1301. X        strncpy(s,line+i,ct);
  1302. X        strcpy(s+ct,cutbuf);
  1303. X        free(cutbuf);
  1304. X        cutbuf = s;
  1305. X    } else {
  1306. X        int x;
  1307. X
  1308. X        cutbuf = realloc(cutbuf,(x = strlen(cutbuf))+ct+1);
  1309. X        ztrncpy(cutbuf+x,line+i,ct);
  1310. X    }
  1311. X}
  1312. X
  1313. Xvoid backdel(ct) /**/
  1314. Xint ct;
  1315. X{
  1316. Xint i = (cs -= ct);
  1317. X
  1318. X    while (line[i] = line[i+ct])
  1319. X        i++;
  1320. X    ll -= ct;
  1321. X}
  1322. X
  1323. Xvoid foredel(ct) /**/
  1324. Xint ct;
  1325. X{
  1326. Xint i = cs;
  1327. X
  1328. X    while (line[i] = line[i+ct])
  1329. X        i++;
  1330. X    ll -= ct;
  1331. X}
  1332. X
  1333. Xvoid setline(s) /**/
  1334. Xchar *s;
  1335. X{
  1336. X    sizeline(strlen(s));
  1337. X    strcpy(line,s);
  1338. X    cs = ll = strlen(s);
  1339. X    if (cs && bindtab == altbindtab) cs--;
  1340. X}
  1341. X
  1342. Xvoid sethistline(s) /**/
  1343. Xchar *s;
  1344. X{
  1345. X    setline(s);
  1346. X    for (s = line; *s; s++)
  1347. X        if (*s == HISTSPACE)
  1348. X            *s = ' ';
  1349. X}
  1350. X
  1351. Xint findbol() /**/
  1352. X{
  1353. Xint x = cs;
  1354. X
  1355. X    while (x > 0 && line[x-1] != '\n') x--;
  1356. X    return x;
  1357. X}
  1358. X
  1359. Xint findeol() /**/
  1360. X{
  1361. Xint x = cs;
  1362. X
  1363. X    while (x != ll && line[x] != '\n') x++;
  1364. X    return x;
  1365. X}
  1366. X
  1367. Xvoid findline(a,b) /**/
  1368. Xint *a;int *b;
  1369. X{
  1370. X    *a = findbol();
  1371. X    *b = findeol();
  1372. X}
  1373. X
  1374. Xstatic int lastlinelen;
  1375. X
  1376. Xvoid initundo() /**/
  1377. X{
  1378. Xint t0;
  1379. X
  1380. X    for (t0 = 0; t0 != UNDOCT; t0++)
  1381. X        undos[t0].change = NULL;
  1382. X    undoct = 0;
  1383. X    lastline = zalloc(lastlinelen = (ll+1 < 32) ? 32 : ll+1);
  1384. X    strcpy(lastline,line);
  1385. X    lastcs = cs;
  1386. X}
  1387. X
  1388. Xvoid addundo() /**/
  1389. X{
  1390. Xint pf,sf;
  1391. Xchar *s,*s2,*t,*t2;
  1392. Xstruct undoent *ue;
  1393. X
  1394. X    for (s = line, t = lastline; *s && *s==*t; s++,t++);
  1395. X    if (!*s && !*t)
  1396. X        return;
  1397. X    pf = s-line;
  1398. X    for (s2 = line+strlen(line), t2 = lastline+strlen(lastline);
  1399. X        s2 > s && t > t2 && s2[-1] == t2[-1]; s2--,t2--);
  1400. X    sf = strlen(s2);
  1401. X    ue = undos+(undoct = (UNDOCT-1) & (undoct+1));
  1402. X    ue->pref = pf;
  1403. X    ue->suff = sf;
  1404. X    ue->len = t2-t;
  1405. X    ue->cs = lastcs;
  1406. X    strncpy(ue->change = halloc(ue->len),t,ue->len);
  1407. X    while (ll+1 > lastlinelen)
  1408. X        {
  1409. X        free(lastline);
  1410. X        lastline = zalloc(lastlinelen *= 2);
  1411. X        }
  1412. X    strcpy(lastline,line);
  1413. X    lastcs = cs;
  1414. X}
  1415. X
  1416. Xvoid freeundo() /**/
  1417. X{
  1418. X    free(lastline);
  1419. X}
  1420. X
  1421. Xint hstrncmp(s,t,len) /**/
  1422. Xchar *s;char *t;int len;
  1423. X{
  1424. X    while (len && *s && (*s == *t || (*s == ' ' && *t == HISTSPACE) ||
  1425. X            (*s == HISTSPACE && *t == ' ')))
  1426. X        s++,t++,len--;
  1427. X    return len;
  1428. X}
  1429. X
  1430. Xint hstrcmp(s,t) /**/
  1431. Xchar *s;char *t;
  1432. X{
  1433. X    while (*s && (*s == *t || (*s == ' ' && *t == HISTSPACE) ||
  1434. X            (*s == HISTSPACE && *t == ' ')))
  1435. X        s++,t++;
  1436. X    return !(*s == '\0' && *t == '\0');
  1437. X}
  1438. X
  1439. Xchar *hstrnstr(s,t,len) /**/
  1440. Xchar *s;char *t;int len;
  1441. X{
  1442. X    for (; *s; s++)
  1443. X        if (!hstrncmp(t,s,len))
  1444. X            return s;
  1445. X    return NULL;
  1446. X}
  1447. X
  1448. SHAR_EOF
  1449. chmod 0644 zsh2.1/src/zle_utils.c ||
  1450. echo 'restore of zsh2.1/src/zle_utils.c failed'
  1451. Wc_c="`wc -c < 'zsh2.1/src/zle_utils.c'`"
  1452. test 4954 -eq "$Wc_c" ||
  1453.     echo 'zsh2.1/src/zle_utils.c: original size 4954, current size' "$Wc_c"
  1454. rm -f _shar_wnt_.tmp
  1455. fi
  1456. # ============= zsh2.1/src/zsh.h ==============
  1457. if test -f 'zsh2.1/src/zsh.h' -a X"$1" != X"-c"; then
  1458.     echo 'x - skipping zsh2.1/src/zsh.h (File already exists)'
  1459.     rm -f _shar_wnt_.tmp
  1460. else
  1461. > _shar_wnt_.tmp
  1462. echo 'x - extracting zsh2.1/src/zsh.h (Text)'
  1463. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.1/src/zsh.h' &&
  1464. X/*
  1465. X
  1466. X    zsh.h - standard header file
  1467. X
  1468. X    This file is part of zsh, the Z shell.
  1469. X
  1470. X    zsh is free software; no one can prevent you from reading the source
  1471. X   code, or giving it to someone else.
  1472. X
  1473. X   This file is copyrighted under the GNU General Public License, which
  1474. X   can be found in the file called COPYING.
  1475. X
  1476. X   Copyright (C) 1990, 1991 Paul Falstad
  1477. X
  1478. X   zsh is distributed in the hope that it will be useful, but
  1479. X   WITHOUT ANY WARRANTY.  No author or distributor accepts
  1480. X   responsibility to anyone for the consequences of using it or for
  1481. X   whether it serves any particular purpose or works at all, unless he
  1482. X   says so in writing.  Refer to the GNU General Public License
  1483. X   for full details.
  1484. X
  1485. X   Everyone is granted permission to copy, modify and redistribute
  1486. X   zsh, but only under the conditions described in the GNU General Public
  1487. X   License.   A copy of this license is supposed to have been given to you
  1488. X   along with zsh so you can know your rights and responsibilities.
  1489. X   It should be in a file named COPYING.
  1490. X
  1491. X   Among other things, the copyright notice and this notice must be
  1492. X   preserved on all copies.
  1493. X
  1494. X*/
  1495. X
  1496. X#include "config.h"
  1497. X
  1498. X#include <stdio.h>
  1499. X#include <string.h>
  1500. X#include <ctype.h>
  1501. X
  1502. X#ifdef SYSV
  1503. X#include <sys/bsdtypes.h>
  1504. X#define _POSIX_SOURCE
  1505. X#include <sys/limits.h>
  1506. X#include <sys/sioctl.h>
  1507. X#define MAXPATHLEN PATH_MAX
  1508. X#define lstat stat
  1509. Xextern int gethostname();
  1510. X#define sigmask(m) m
  1511. X#include <sys/dirent.h>
  1512. Xstruct rusage { int foo; }
  1513. X#else
  1514. X#include <sys/types.h>        /* this is the key to the whole thing */
  1515. X#endif
  1516. X
  1517. X#include <sys/wait.h>
  1518. X#include <sys/time.h>
  1519. X#ifndef SYSV
  1520. X#include <sys/resource.h>
  1521. X#endif
  1522. X#include <sys/file.h>
  1523. X#include <signal.h>
  1524. X#ifdef TERMIO
  1525. X#include <sys/termio.h>
  1526. X#else
  1527. X#ifdef TERMIOS
  1528. X#include <sys/termios.h>
  1529. X#else
  1530. X#include <sgtty.h>
  1531. X#endif
  1532. X#endif
  1533. X
  1534. X#ifdef SYSV
  1535. X#undef TIOCGWINSZ
  1536. X#endif
  1537. X
  1538. X#include <sys/param.h>
  1539. X
  1540. X#ifdef SYSV
  1541. X#undef _POSIX_SOURCE
  1542. X#endif
  1543. X
  1544. X#ifdef __hp9000s800
  1545. X#include <sys/bsdtty.h>
  1546. X#endif
  1547. X
  1548. X#define VERSIONSTR "zsh v2.1.0"
  1549. X
  1550. X#if 0 /* __STDC__ */
  1551. X#include <unistd.h>
  1552. X#include <stdlib.h>
  1553. X#include <fcntl.h>
  1554. X#include <stat.h>
  1555. X#define DCLPROTO(X) X
  1556. X#undef NULL
  1557. X#define NULL ((void *)0)
  1558. X#else /* not __STDC__ */
  1559. X#include <sys/stat.h>
  1560. X#define DCLPROTO(X) ()
  1561. X#ifndef NULL
  1562. X#define NULL 0
  1563. X#endif
  1564. X#endif /* __STDC__ */
  1565. X
  1566. X#define DEFWORDCHARS "*?_-.[]~=/&;!#$%^(){}<>"
  1567. X#define DEFTIMEFMT "%E real  %U user  %S system  %P"
  1568. X#ifdef UTMP_HOST
  1569. X#define DEFWATCHFMT "%n has %a %l from %m."
  1570. X#else
  1571. X#define DEFWATCHFMT "%n has %a %l."
  1572. X#endif
  1573. X
  1574. X#ifdef GLOBALS
  1575. X#define EXTERN
  1576. X#else
  1577. X#define EXTERN extern
  1578. X#endif
  1579. X
  1580. X#ifndef F_OK
  1581. X#define F_OK 00
  1582. X#define R_OK 04
  1583. X#define W_OK 02
  1584. X#define X_OK 01
  1585. X#endif
  1586. X
  1587. X#include "zle.h"
  1588. X
  1589. X/* size of job list */
  1590. X
  1591. X#define MAXJOB 80
  1592. X
  1593. X/* memory allocation routines - changed with permalloc()/heapalloc() */
  1594. X
  1595. Xvptr (*alloc)DCLPROTO((int));
  1596. Xvptr (*ncalloc)DCLPROTO((int));
  1597. X
  1598. X#define addhnode(A,B,C,D) Addhnode(A,B,C,D,1)
  1599. X#define addhperm(A,B,C,D) Addhnode(A,B,C,D,0)
  1600. X
  1601. X/* character tokens */
  1602. X
  1603. X#define ALPOP            ((char) 0x81)
  1604. X#define HISTSPACE        ((char) 0x83)
  1605. X#define Pound            ((char) 0x84)
  1606. X#define String            ((char) 0x85)
  1607. X#define Hat                ((char) 0x86)
  1608. X#define Star            ((char) 0x87)
  1609. X#define Inpar            ((char) 0x88)
  1610. X#define Outpar            ((char) 0x89)
  1611. X#define Qstring        ((char) 0x8a)
  1612. X#define Equals            ((char) 0x8b)
  1613. X#define Bar                ((char) 0x8c)
  1614. X#define Inbrace        ((char) 0x8d)
  1615. X#define Outbrace        ((char) 0x8e)
  1616. X#define Inbrack        ((char) 0x8f)
  1617. X#define Outbrack        ((char) 0x90)
  1618. X#define Tick            ((char) 0x91)
  1619. X#define Inang            ((char) 0x92)
  1620. X#define Outang            ((char) 0x93)
  1621. X#define Quest            ((char) 0x94)
  1622. X#define Tilde            ((char) 0x95)
  1623. X#define Qtick            ((char) 0x96)
  1624. X#define Comma            ((char) 0x97)
  1625. X#define Nularg            ((char) 0x98)
  1626. X
  1627. X/* chars that need to be quoted if meant literally */
  1628. X
  1629. X#define SPECCHARS "#$^*()$=|{}[]`<>?~;&!\n\t \\\'\""
  1630. X
  1631. X/* ALPOP in the form of a string */
  1632. X
  1633. X#define ALPOPS " \201"
  1634. X#define HISTMARK "\201"
  1635. X
  1636. X#define SEPER 1
  1637. X#define NEWLIN 2
  1638. X#define LEXERR 3
  1639. X#define SEMI 4
  1640. X#define DSEMI 5
  1641. X#define AMPER 6
  1642. X#define INPAR 7
  1643. X#define INBRACE 8
  1644. X#define OUTPAR 9
  1645. X#define DBAR 10
  1646. X#define DAMPER 11
  1647. X#define BANG 12
  1648. X#define OUTBRACE 13
  1649. X#define OUTANG 14
  1650. X#define OUTANGBANG 15
  1651. X#define DOUTANG 16
  1652. X#define DOUTANGBANG 17
  1653. X#define INANG 18
  1654. X#define DINANG 19
  1655. X#define DINANGDASH 20
  1656. X#define INANGAMP 21
  1657. X#define OUTANGAMP 22
  1658. X#define OUTANGAMPBANG 23
  1659. X#define DOUTANGAMP 24
  1660. X#define DOUTANGAMPBANG 25
  1661. X#define TRINANG 26
  1662. X#define BAR 27
  1663. X#define BARAMP 28
  1664. X#define DINBRACK 29
  1665. X#define DOUTBRACK 30
  1666. X#define STRING 31
  1667. X#define ENVSTRING 32
  1668. X#define ENVARRAY 33
  1669. X#define ENDINPUT 34
  1670. X#define INOUTPAR 35
  1671. X#define DO 36
  1672. X#define DONE 37
  1673. X#define ESAC 38
  1674. X#define THEN 39
  1675. X#define ELIF 40
  1676. X#define ELSE 41
  1677. X#define FI 42
  1678. X#define FOR 43
  1679. X#define CASE 44
  1680. X#define IF 45
  1681. X#define WHILE 46
  1682. X#define FUNC 47
  1683. X#define REPEAT 48
  1684. X#define TIME 49
  1685. X#define UNTIL 50
  1686. X#define EXEC 51
  1687. X#define COMMAND 52
  1688. X#define SELECT 53
  1689. X#define COPROC 54
  1690. X#define NOGLOB 55
  1691. X#define DASH 56
  1692. X#define NOCORRECT 57
  1693. X#define FOREACH 58
  1694. X#define ZEND 59
  1695. X
  1696. X#define WRITE 0
  1697. X#define WRITENOW 1
  1698. X#define APP 2
  1699. X#define APPNOW 3
  1700. X#define MERGEOUT 4
  1701. X#define MERGEOUTNOW 5
  1702. X#define ERRAPP 6
  1703. X#define ERRAPPNOW 7
  1704. X#define READ 8
  1705. X#define HEREDOC 9
  1706. X#define MERGE 10
  1707. X#define CLOSE 11
  1708. X#define INPIPE 12
  1709. X#define OUTPIPE 13
  1710. X#define HERESTR 14
  1711. X#define NONE 15
  1712. X#define HEREDOCDASH 16
  1713. X
  1714. X#ifdef GLOBALS
  1715. Xint redirtab[TRINANG-OUTANG+1] = {
  1716. X    WRITE,
  1717. X    WRITENOW,
  1718. X    APP,
  1719. X    APPNOW,
  1720. X    READ,
  1721. X    HEREDOC,
  1722. X    HEREDOCDASH,
  1723. X    MERGE,
  1724. X    MERGEOUT,
  1725. X    MERGEOUTNOW,
  1726. X    ERRAPP,
  1727. X    ERRAPPNOW,
  1728. X    HERESTR,
  1729. X};
  1730. X#else
  1731. Xint redirtab[TRINANG-OUTANG+1];
  1732. X#endif
  1733. X
  1734. X#define IS_READFD(X) (((X)>=READ && (X)<=MERGE)||(X)==HEREDOCDASH||(X)==HERESTR)
  1735. X#define IS_REDIROP(X) ((X)>=OUTANG && (X)<=TRINANG)
  1736. X#define IS_ERROR_REDIR(X) ((X)>=MERGEOUT && (X)<=ERRAPPNOW)
  1737. X#define UN_ERROR_REDIR(X) ((X)-MERGEOUT+WRITE)
  1738. X
  1739. XEXTERN char **environ;
  1740. X
  1741. Xtypedef struct hashtab *Hashtab;
  1742. Xtypedef struct hashnode *Hashnode;
  1743. Xtypedef struct schedcmd *Schedcmd;
  1744. Xtypedef struct alias *Alias;
  1745. Xtypedef struct process *Process;
  1746. Xtypedef struct job *Job;
  1747. Xtypedef struct value *Value;
  1748. Xtypedef struct arrind *Arrind;
  1749. Xtypedef struct varasg *Varasg;
  1750. Xtypedef struct param *Param;
  1751. Xtypedef struct cmdnam *Cmdnam;
  1752. Xtypedef struct cond *Cond;
  1753. Xtypedef struct cmd *Cmd;
  1754. Xtypedef struct pline *Pline;
  1755. Xtypedef struct sublist *Sublist;
  1756. Xtypedef struct list *List;
  1757. Xtypedef struct lklist *Lklist;
  1758. Xtypedef struct lknode *Lknode;
  1759. Xtypedef struct comp *Comp;
  1760. Xtypedef struct redir *Redir;
  1761. Xtypedef struct complist *Complist;
  1762. Xtypedef struct heap *Heap;
  1763. Xtypedef void (*FFunc)DCLPROTO((vptr));
  1764. Xtypedef vptr (*VFunc)DCLPROTO((vptr));
  1765. Xtypedef void (*HFunc)DCLPROTO((char *,char *));
  1766. X
  1767. X/* linked list abstract data type */
  1768. X
  1769. Xstruct lknode;
  1770. Xstruct lklist;
  1771. X
  1772. Xstruct lknode {
  1773. X   Lknode next,last;
  1774. X   vptr dat;
  1775. X   };
  1776. Xstruct lklist {
  1777. X   Lknode first,last;
  1778. X   };
  1779. X
  1780. X#define addnode(X,Y) insnode(X,(X)->last,Y)
  1781. X#define full(X) ((X)->first != NULL)
  1782. X#define firstnode(X) ((X)->first)
  1783. X#define getaddrdata(X) (&((X)->dat))
  1784. X#define getdata(X) ((X)->dat)
  1785. X#define setdata(X,Y) ((X)->dat = (Y))
  1786. X#define lastnode(X) ((X)->last)
  1787. X#define nextnode(X) ((X)->next)
  1788. X#define prevnode(X) ((X)->last)
  1789. X#define peekfirst(X) ((X)->first->dat)
  1790. X#define pushnode(X,Y) insnode(X,(Lknode) X,Y)
  1791. X#define incnode(X) (X = nextnode(X))
  1792. X
  1793. X/* node structure for syntax trees */
  1794. X
  1795. X/* struct list, struct sublist, struct pline, etc.  all fit the form
  1796. X    of this structure and are used interchangably
  1797. X*/
  1798. X
  1799. Xstruct node {
  1800. X    int data[4];            /* arbitrary integer data */
  1801. X    vptr ptrs[4];            /* arbitrary pointer data */
  1802. X    int types[4];            /* what ptrs[] are pointing to */
  1803. X    int type;                /* node type */
  1804. X    };
  1805. X
  1806. X#define N_LIST 0
  1807. X#define N_SUBLIST 1
  1808. X#define N_PLINE 2
  1809. X#define N_CMD 3
  1810. X#define N_REDIR 4
  1811. X#define N_COND 5
  1812. X#define N_FOR 6
  1813. X#define N_CASE 7
  1814. X#define N_IF 8
  1815. X#define N_WHILE 9
  1816. X#define N_VARASG 10
  1817. X#define N_COUNT 11
  1818. X
  1819. X/* values for types[4] */
  1820. X
  1821. X#define NT_EMPTY 0
  1822. X#define NT_NODE  1
  1823. X#define NT_STR   2
  1824. X#define NT_LIST  4
  1825. X#define NT_MALLOC 8
  1826. X
  1827. X/* tree element for lists */
  1828. X
  1829. Xstruct list {
  1830. X    int type;
  1831. X    int ifil[3];        /* to fit struct node */
  1832. X   Sublist left;
  1833. X   List right;
  1834. X   };
  1835. X
  1836. X#define SYNC 0        /* ; */
  1837. X#define ASYNC 1    /* & */
  1838. X#define TIMED 2
  1839. X
  1840. X/* tree element for sublists */
  1841. X
  1842. Xstruct sublist {
  1843. X    int type;
  1844. X    int flags;            /* see PFLAGs below */
  1845. X    int ifil[2];
  1846. X    Pline left;
  1847. X    Sublist right;
  1848. X    };
  1849. X
  1850. X#define ORNEXT 10        /* || */
  1851. X#define ANDNEXT 11    /* && */
  1852. X
  1853. X#define PFLAG_NOT 1            /* ! ... */
  1854. X#define PFLAG_COPROC 32        /* coproc ... */
  1855. X
  1856. X/* tree element for pipes */
  1857. X
  1858. Xstruct pline {
  1859. X    int type;
  1860. X    int ifil[3];
  1861. X   Cmd left;
  1862. X   Pline right;
  1863. X   };
  1864. X
  1865. X#define END        0    /* pnode *right is null */
  1866. X#define PIPE    1    /* pnode *right is the rest of the pipeline */
  1867. X
  1868. X/* tree element for commands */
  1869. X
  1870. Xstruct cmd {
  1871. X    int type;
  1872. X    int flags;                /* see CFLAGs below */
  1873. X    int ifil[2];
  1874. X   Lklist args;            /* command & argmument List (char *'s) */
  1875. X    union {
  1876. X       List list;            /* for SUBSH/CURSH/SHFUNC */
  1877. X        struct forcmd *forcmd;
  1878. X        struct casecmd *casecmd;
  1879. X        struct ifcmd *ifcmd;
  1880. X        struct whilecmd *whilecmd;
  1881. X        Sublist pline;
  1882. X        Cond cond;
  1883. X        } u;
  1884. X   Lklist redir;            /* i/o redirections (struct redir *'s) */
  1885. X    Lklist vars;            /* param assignments (struct varasg *'s) */
  1886. X   };
  1887. X
  1888. X#define SIMPLE 0
  1889. X#define SUBSH 1
  1890. X#define ZCTIME 2
  1891. X#define CURSH 3
  1892. X#define FUNCDEF 4
  1893. X#define CFOR 5
  1894. X#define CWHILE 6
  1895. X#define CREPEAT 7
  1896. X#define CIF 8
  1897. X#define CCASE 9
  1898. X#define CSELECT 10
  1899. X#define COND 11
  1900. X
  1901. X#define CFLAG_EXEC 1            /* exec ... */
  1902. X#define CFLAG_COMMAND 2        /* command ... */
  1903. X#define CFLAG_NOGLOB 4     /* noglob ... */
  1904. X#define CFLAG_DASH 8            /* - ... */
  1905. X
  1906. X/* tree element for redirection lists */
  1907. X
  1908. Xstruct redir {
  1909. X    int type,fd1,fd2,ifil;
  1910. X    char *name;
  1911. X   };
  1912. X
  1913. X/* tree element for conditionals */
  1914. X
  1915. Xstruct cond {
  1916. X    int type;        /* can be cond_type, or a single letter (-a, -b, ...) */
  1917. X    int ifil[3];
  1918. X    vptr left,right,vfil[2];
  1919. X    int types[4],typ;    /* from struct node.  DO NOT REMOVE */
  1920. X    };
  1921. X
  1922. X#define COND_NOT 0
  1923. X#define COND_AND 1
  1924. X#define COND_OR 2
  1925. X#define COND_STREQ 3
  1926. X#define COND_STRNEQ 4
  1927. X#define COND_STRLT 5
  1928. X#define COND_STRGTR 6
  1929. X#define COND_NT 7
  1930. X#define COND_OT 8
  1931. X#define COND_EF 9
  1932. X#define COND_EQ 10
  1933. X#define COND_NE 11
  1934. X#define COND_LT 12
  1935. X#define COND_GT 13
  1936. X#define COND_LE 14
  1937. X#define COND_GE 15
  1938. X
  1939. Xstruct forcmd {        /* for/select */
  1940. X                            /* Cmd->args contains list of words to loop thru */
  1941. X    int inflag;            /* if there is an in ... clause */
  1942. X    int ifil[3];
  1943. X    char *name;            /* parameter to assign values to */
  1944. X    List list;            /* list to look through for each name */
  1945. X    };
  1946. Xstruct casecmd {
  1947. X                            /* Cmd->args contains word to test */
  1948. X    int ifil[4];
  1949. X    struct casecmd *next;
  1950. X    char *pat;
  1951. X    List list;                    /* list to execute */
  1952. X    };
  1953. X
  1954. X/*
  1955. X
  1956. X    a command like "if foo then bar elif baz then fubar else fooble"
  1957. X    generates a tree like:
  1958. X
  1959. X    struct ifcmd a = { next =  &b,  ifl = "foo", thenl = "bar" }
  1960. X    struct ifcmd b = { next =  &c,  ifl = "baz", thenl = "fubar" }
  1961. X    struct ifcmd c = { next = NULL, ifl = NULL, thenl = "fooble" }
  1962. X
  1963. X*/
  1964. X
  1965. Xstruct ifcmd {
  1966. X    int ifil[4];
  1967. X    struct ifcmd *next;
  1968. X    List ifl;
  1969. X    List thenl;
  1970. X    };
  1971. X
  1972. Xstruct whilecmd {
  1973. X    int cond;        /* 0 for while, 1 for until */
  1974. X    int ifil[3];
  1975. X    List cont;        /* condition */
  1976. X    List loop;        /* list to execute until condition met */
  1977. X    };
  1978. X
  1979. X/* structure used for multiple i/o redirection */
  1980. X/* one for each fd open */
  1981. X
  1982. Xstruct multio {
  1983. X    int ct;                /* # of redirections on this fd */
  1984. X    int rflag;            /* 0 if open for reading, 1 if open for writing */
  1985. X    int pipe;            /* fd of pipe if ct > 1 */
  1986. X    int fds[NOFILE];    /* list of src/dests redirected to/from this fd */
  1987. X   }; 
  1988. X
  1989. X/* node used in command path hash table (cmdnamtab) */
  1990. X
  1991. Xstruct cmdnam 
  1992. X{
  1993. X    int type,flags;
  1994. X    int ifil[2];
  1995. X    union {
  1996. X        char *nam;        /* full pathname if type != BUILTIN */
  1997. X        int binnum;        /* func to exec if type == BUILTIN */
  1998. X        List list;        /* list to exec if type == SHFUNC */
  1999. X        } u;
  2000. X    };
  2001. X
  2002. X#define EXCMD_PREDOT 0
  2003. X#define EXCMD_POSTDOT 1
  2004. X#define BUILTIN 2
  2005. X#define SHFUNC 3
  2006. X#define DISABLED 4
  2007. X#define ISEXCMD(X) ((X)==EXCMD_PREDOT||(X)==EXCMD_POSTDOT)
  2008. X
  2009. X/* node used in parameter hash table (paramtab) */
  2010. X
  2011. Xstruct param {
  2012. X    union {
  2013. X        char **arr;        /* value if declared array */
  2014. X        char *str;        /* value if declared string (scalar) */
  2015. X        long val;        /* value if declared integer */
  2016. X        } u;
  2017. X    union {                /* functions to call to set value */
  2018. X        void (*cfn)DCLPROTO((Param,char *));
  2019. X        void (*ifn)DCLPROTO((Param,long));
  2020. X        void (*afn)DCLPROTO((Param,char **));
  2021. X        } sets;
  2022. X    union {                /* functions to call to get value */
  2023. X        char *(*cfn)DCLPROTO((Param));
  2024. X        long (*ifn)DCLPROTO((Param));
  2025. X        char **(*afn)DCLPROTO((Param));
  2026. X        } gets;
  2027. X    int ct;                /* output base or field width */
  2028. X    int flags;
  2029. X    vptr data;            /* used by getfns */
  2030. X    char *env;            /* location in environment, if exported */
  2031. X    char *ename;        /* name of corresponding environment var */
  2032. X    };
  2033. X
  2034. X#define PMFLAG_s 0        /* scalar */
  2035. X#define PMFLAG_L 1        /* left justify and remove leading blanks */
  2036. X#define PMFLAG_R 2        /* right justify and fill with leading blanks */
  2037. X#define PMFLAG_Z 4        /* right justify and fill with leading zeros */
  2038. X#define PMFLAG_i 8        /* integer */
  2039. X#define PMFLAG_l 16        /* all lower case */
  2040. X#define PMFLAG_u 32        /* all upper case */
  2041. X#define PMFLAG_r 64        /* readonly */
  2042. X#define PMFLAG_t 128        /* tagged */
  2043. X#define PMFLAG_x 256        /* exported */
  2044. X#define PMFLAG_A 512        /* array */
  2045. X#define PMFLAG_SPECIAL    1024
  2046. X#define PMTYPE (PMFLAG_i|PMFLAG_A)
  2047. X#define pmtype(X) ((X)->flags & PMTYPE)
  2048. X
  2049. X/* variable assignment tree element */
  2050. X
  2051. Xstruct varasg {
  2052. X    int type;            /* nonzero means array */
  2053. X    int ifil[3];
  2054. X    char *name;
  2055. X    char *str;            /* should've been a union here.  oh well */
  2056. X    Lklist arr;
  2057. X    };
  2058. X
  2059. X/* lvalue for variable assignment/expansion */
  2060. X
  2061. Xstruct value {
  2062. X    int isarr;
  2063. X    struct param *pm;        /* parameter node */
  2064. X    int a;                    /* first element of array slice, or -1 */
  2065. X    int b;                    /* last element of array slice, or -1 */
  2066. X    };
  2067. X
  2068. Xstruct fdpair {
  2069. X    int fd1,fd2;
  2070. X    };
  2071. X
  2072. X/* tty state structure */
  2073. X
  2074. Xstruct ttyinfo {
  2075. X#ifdef TERMIOS
  2076. X    struct termios termios;
  2077. X#else
  2078. X#ifdef TERMIO
  2079. X    struct termio termio;
  2080. X#else
  2081. X    struct sgttyb sgttyb;
  2082. X    int lmodes;
  2083. X    struct tchars tchars;
  2084. X    struct ltchars ltchars;
  2085. X#endif
  2086. X#endif
  2087. X#ifdef TIOCGWINSZ
  2088. X    struct winsize winsize;
  2089. X#endif
  2090. X    };
  2091. X
  2092. XEXTERN struct ttyinfo savedttyinfo;
  2093. X
  2094. X/* entry in job table */
  2095. X
  2096. Xstruct job {
  2097. X    long gleader;                    /* process group leader of this job */
  2098. X    int stat;
  2099. X    char *cwd;                        /* current working dir of shell when
  2100. X                                            this job was spawned */
  2101. X    struct process *procs;        /* list of processes */
  2102. X    Lklist filelist;                /* list of files to delete when done */
  2103. X    };
  2104. X
  2105. X#define STAT_CHANGED 1        /* status changed and not reported */
  2106. X#define STAT_STOPPED 2        /* all procs stopped or exited */
  2107. X#define STAT_TIMED 4            /* job is being timed */
  2108. X#define STAT_DONE 8
  2109. X#define STAT_LOCKED 16        /* shell is finished creating this job,
  2110. X                                        may be deleted from job table */
  2111. X#define STAT_INUSE 64        /* this job entry is in use */
  2112. X
  2113. X#define SP_RUNNING -1        /* fake statusp for running jobs */
  2114. X
  2115. X/* node in job process lists */
  2116. X
  2117. Xstruct process {
  2118. X    struct process *next;
  2119. X    long pid;
  2120. X    char *text;                        /* text to print when 'jobs' is run */
  2121. X    int statusp;                    /* return code from wait3() */
  2122. X    int lastfg;                        /* set if this process represents a
  2123. X                                            fragment of a pipeline run in a subshell
  2124. X                                            for commands like:
  2125. X
  2126. X                                            foo | bar | ble
  2127. X
  2128. X                                            where foo is a current shell function
  2129. X                                            or control structure.  The command
  2130. X                                            actually executed is:
  2131. X
  2132. X                                            foo | (bar | ble)
  2133. X
  2134. X                                            That's two procnodes in the parent
  2135. X                                            shell, the latter having this flag set. */
  2136. X    struct rusage ru;
  2137. X    time_t bgtime;                    /* time job was spawned */
  2138. X    time_t endtime;                /* time job exited */
  2139. X    };
  2140. X
  2141. X/* node in alias hash table */
  2142. X
  2143. Xstruct alias {
  2144. X    char *text;            /* expansion of alias */
  2145. X    int cmd;                /* one for regular aliases,
  2146. X                                zero for global aliases,
  2147. X                                negative for reserved words */
  2148. X    int inuse;            /* alias is being expanded */
  2149. X    };
  2150. X
  2151. X/* node in sched list */
  2152. X
  2153. Xstruct schedcmd {
  2154. X    struct schedcmd *next;
  2155. X    char *cmd;        /* command to run */
  2156. X    time_t time;    /* when to run it */
  2157. X    };
  2158. X
  2159. X#define MAXAL 20    /* maximum number of aliases expanded at once */
  2160. X
  2161. X/* hash table node */
  2162. X
  2163. Xstruct hashnode {
  2164. X    struct hashnode *next;
  2165. X    char *nam;
  2166. X    vptr dat;
  2167. X    int canfree;        /* nam is free()able */
  2168. X    };
  2169. X
  2170. X/* hash table */
  2171. X
  2172. Xstruct hashtab {
  2173. X    int hsize;                            /* size of nodes[] */
  2174. X    int ct;                                /* # of elements */
  2175. X    struct hashnode **nodes;        /* array of size hsize */
  2176. X    };
  2177. X
  2178. Xextern char *sys_errlist[];
  2179. Xextern int errno;
  2180. X
  2181. X/* values in opts[] array */
  2182. X
  2183. X#define OPT_INVALID 1    /* opt is invalid, like -$ */
  2184. X#define OPT_UNSET 0
  2185. X#define OPT_SET 2
  2186. X
  2187. X/* the options */
  2188. X
  2189. Xstruct option {
  2190. X    char *name;
  2191. X    char id;            /* corresponding letter */
  2192. X    };
  2193. X
  2194. X#define CORRECT '0'
  2195. X#define NOCLOBBER '1'
  2196. X#define NOBADPATTERN '2'
  2197. X#define NONOMATCH '3'
  2198. X#define GLOBDOTS '4'
  2199. X#define NOTIFY '5'
  2200. X#define BGNICE '6'
  2201. X#define IGNOREEOF '7'
  2202. X#define MARKDIRS '8'
  2203. X#define AUTOLIST '9'
  2204. X#define NOBEEP 'B'
  2205. X#define PRINTEXITVALUE 'C'
  2206. X#define PUSHDTOHOME 'D'
  2207. X#define PUSHDSILENT 'E'
  2208. X#define NOGLOBOPT 'F'
  2209. X#define NULLGLOB 'G'
  2210. X#define RMSTARSILENT 'H'
  2211. X#define IGNOREBRACES 'I'
  2212. X#define AUTOCD 'J'
  2213. X#define NOBANGHIST 'K'
  2214. X#define SUNKEYBOARDHACK 'L'
  2215. X#define SINGLELINEZLE 'M'
  2216. X#define AUTOPUSHD 'N'
  2217. X#define CORRECTALL 'O'
  2218. X#define RCEXPANDPARAM 'P'
  2219. X#define PATHDIRS 'Q'
  2220. X#define LONGLISTJOBS 'R'
  2221. X#define RECEXACT 'S'
  2222. X#define CDABLEVARS 'T'
  2223. X#define MAILWARNING 'U'
  2224. X#define NOPROMPTCLOBBER 'V'
  2225. X#define AUTORESUME 'W'
  2226. X#define LISTTYPES 'X'
  2227. SHAR_EOF
  2228. true || echo 'restore of zsh2.1/src/zsh.h failed'
  2229. fi
  2230. echo 'End of zsh2.1.0 part 12'
  2231. echo 'File zsh2.1/src/zsh.h is continued in part 13'
  2232. echo 13 > _shar_seq_.tmp
  2233. exit 0
  2234.  
  2235. exit 0 # Just in case...
  2236. -- 
  2237. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2238. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2239. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2240. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2241.